home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / src / exampleCode / opengl / GLUT / progs / demos / walker / walker.c < prev    next >
C/C++ Source or Header  |  1996-11-11  |  28KB  |  1,105 lines
  1. #include <GL/glut.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <math.h>
  5. #include <string.h>
  6. #include <dirent.h>
  7. #include <assert.h>
  8.  
  9. #include "walker.h"
  10.  
  11.  
  12.  
  13. #define MAX(x,y) ((x) > (y) ? (x) : (y))
  14. #define MIN(x,y) ((x) < (y) ? (x) : (y))
  15.  
  16. #define CYCLE_SIZE 100
  17. #define CYCLE_STEP 1.0/CYCLE_SIZE
  18. #define OVERSAMPLE 10
  19.  
  20. #define MAX_CPOINTS 34   /* 2 end point ones and 10 in the middle */
  21.  
  22. #define MAX_CSETNAMELEN 25
  23.  
  24. #define NUM_JOINTS 5
  25.  
  26. #define CSET_EXT ".cset"
  27. #define CSET_EXTLEN 5
  28.  
  29. #include "walkviewer.h"
  30.  
  31.  
  32. typedef enum { CMENU_QUIT, CMENU_CURVE, CMENU_HORIZ, CMENU_RESET,
  33.                CMENU_WALK, CMENU_DONEEDIT, CMENU_SAVE, CMENU_LOAD,
  34.            CMENU_MIRROR
  35.               } CurveMenuChoices;
  36.  
  37. typedef enum { WIRECUBE, SOLIDCUBE, CYLINDER1, CYLINDER2 } ModelTypes;
  38.  
  39. int GuyModel = SOLIDCUBE;
  40.  
  41. /***************************************************************/
  42. /*************************** GLOBALS ***************************/
  43. /***************************************************************/
  44.  
  45. GLuint HorizontalList, AxesList,     /* Display lists */
  46.        CurveLists, ControlPtsLists;  /* Firsts of groups of display lists */
  47.  
  48. int CurveAsPoints   =  0,    /* Display curve as points? */
  49.     DrawHorizontals =  0,    /* Draw horizontal lines?   */
  50.     EditingCurve    = -1;    /* Editing what curve, -1 means none */
  51.  
  52. int CurveWindow,   /* Glut window id's to two top level windows */
  53.     GuyWindow;
  54.  
  55. int MirrorLegs = 0;
  56.  
  57. int CurveMenu     = -1,
  58.     CurveEditMenu = -1,
  59.     StepSizeMenu  = -1,
  60.     LoadMenu      = -1,
  61.     SaveMenu      = -1;
  62.  
  63. char *CSetNames[MAX_CSETNAMELEN];
  64.  
  65. int CurrentCurve = -1;  /* Curve loaded, index to CSetNames */
  66.  
  67. GLfloat Walk_cycle[2][NUM_JOINTS][CYCLE_SIZE];  /* array of computed angles */
  68.  
  69. int Step = CYCLE_SIZE/2;  /* Position in cycle, start in middle */
  70.  
  71. float fStep = CYCLE_SIZE/2;   /* floating point for non-integer steping */
  72. float IncStep = 1.0;
  73.  
  74. typedef struct ControlPts {
  75.   int numpoints;
  76.   float xcoords[MAX_CPOINTS];
  77.   float angles[MAX_CPOINTS];
  78. } tControlPts;
  79.  
  80. tControlPts RotCurve[NUM_JOINTS];   /* series of cntrl points for ea joint */
  81.  
  82. int Walking         = 0,     /* Guy is walking? */
  83.     ViewPerspective = 1,     /* Perspective or orthographic views */
  84.     DrawAxes        = 0;     /* Draw axes for alignment */
  85.  
  86. int CurveWWidth,             /* Dimensions of curve window */
  87.     CurveWHeight;  
  88.  
  89. int CurveDownBtn = -1,               /* mouse stuff, for editing curves */
  90.     WasWalking,
  91.     CurvePickedPoint = -1,
  92.     CurveLastX,
  93.     CurveLastY;
  94.  
  95. int CurveWindowVisible = 1;
  96.  
  97.  
  98.   /* prototypes */
  99. void RedisplayBoth(void);
  100. void IncrementStep(void);
  101. void CurveCPointDrag(void);
  102. void CurveHandleMenu(int value);
  103. void StopWalking(void);
  104. void CurveHandleEditMenu(int curve);
  105. void ComputeCSetAndMakeLists(void);
  106. int MakeLoadAndSaveMenus(void);
  107. void CurveMenuInit(void);
  108. void SetWindowTitles(char *csetname);
  109.  
  110. /***************************************************************/
  111. /**************************** BEZIER ***************************/
  112. /***************************************************************/
  113.  
  114.   /* Matrix times a vector  dest = m*v */
  115. void MultMV(float m[3][4], float v[4], float dest[3])
  116. {
  117.   int i, j;
  118.  
  119.   for (i = 0; i < 3; i++) {
  120.     dest[i] = 0;
  121.     for (j = 0; j < 4; j++)
  122.       dest[i] += m[i][j] * v[j];
  123.   }
  124. }
  125.  
  126.   /* Matrix multiplication, dest = m1*m2 */
  127. void MultM(float m1[3][4], float m2[4][4], float dest[3][4])
  128. {
  129.   int i, j, k;
  130.  
  131.   for (i = 0; i < 3; i++)
  132.     for (j = 0; j < 4; j++) {
  133.       dest[i][j] = 0;
  134.       for (k = 0; k < 4; k++)
  135.       dest[i][j] += (m1[i][k] * m2[k][j]);
  136.     }
  137. }
  138.  
  139. void ComputeCurve(int joint)
  140. {
  141.   float prod[3][4], tm[4], pos[3];
  142.   float t = 0, tinc = (float)CYCLE_STEP/OVERSAMPLE;
  143.   int ctlpoint, i;
  144.   float BBasis[4][4] = {{-1, 3, -3, 1}, {3, -6, 3, 0},
  145.                         {-3, 3,  0, 0}, {1,  0, 0, 0}};
  146.   int lastindex, newindex;
  147.  
  148.   float pointset[3][4];
  149.   for (i = 0; i < 4; i++)   /* z's are always zero, only 2-d */
  150.     pointset[2][i] = 0; 
  151.  
  152.   lastindex = -1;
  153.   for(ctlpoint = 0; ctlpoint < RotCurve[joint].numpoints; ctlpoint += 3) {
  154.     t = 0;
  155.     for (i = 0; i < 4; i++)
  156.       pointset[0][i] = RotCurve[joint].xcoords[ctlpoint + i];
  157.     for (i = 0; i < 4; i++)
  158.       pointset[1][i] = RotCurve[joint].angles[ctlpoint + i];
  159.  
  160.     MultM(pointset, BBasis, prod);
  161.  
  162.     while (t <= 1) {
  163.       tm[0] = t*t*t;
  164.       tm[1] = t*t;
  165.       tm[2] = t;
  166.       tm[3] = 1;
  167.       MultMV(prod, tm, pos);
  168.       newindex = (int)(pos[0]*(CYCLE_SIZE-1));
  169.       if ((int)(newindex > lastindex))  {  /* go at least one */
  170.     Walk_cycle[0][joint][newindex] = pos[1];
  171.     lastindex++;
  172.       } 
  173.       t += tinc;
  174.     }
  175.   }
  176.  
  177.   for (i = 0; i < CYCLE_SIZE; i++) {      /* copy to other leg, out-o-phase */
  178.     if (MirrorLegs)
  179.       Walk_cycle[1][joint][i] =
  180.         Walk_cycle[0][joint][i];
  181.     else
  182.       Walk_cycle[1][joint][i] =
  183.         Walk_cycle[0][joint][(i+(CYCLE_SIZE/2))%CYCLE_SIZE];
  184.   }
  185. }
  186.  
  187. /***************************************************************/
  188. /************************* CURVE I/O ***************************/
  189. /***************************************************************/
  190.  
  191. void FlatCSet(void)
  192. {
  193.   int joint;
  194.  
  195.   for (joint = 0; joint < NUM_JOINTS; joint++) {
  196.     RotCurve[joint].numpoints = 4;
  197.     RotCurve[joint].xcoords[0] = 0.0;
  198.     RotCurve[joint].angles[0]  = 0.0;
  199.     RotCurve[joint].xcoords[1] = 0.2;
  200.     RotCurve[joint].angles[1]  = 0.0;
  201.     RotCurve[joint].xcoords[2] = 0.8;
  202.     RotCurve[joint].angles[2]  = 0.0;
  203.     RotCurve[joint].xcoords[3] = 1.0;
  204.     RotCurve[joint].angles[3]  = 0.0;
  205.   }
  206. }
  207.  
  208. int ReadCSetFromFile(char *filename)
  209. {
  210.   FILE *infile = fopen(filename, "r");
  211.   int numjoints, numpoints, joint, point, mirrorlegs;
  212.   float value;
  213.  
  214.   if (infile == NULL)
  215.     goto abort;
  216.   
  217.   if (!fscanf(infile, " %d", &numjoints) || numjoints != NUM_JOINTS)
  218.     goto abort;
  219.  
  220.   if (!fscanf(infile, " %d", &mirrorlegs) || (mirrorlegs != 0 &&
  221.                                               mirrorlegs != 1))
  222.     goto abort;
  223.  
  224.   MirrorLegs = mirrorlegs;
  225.  
  226.   for (joint = 0; joint < NUM_JOINTS; joint++) {
  227.     if (!fscanf(infile, " %d", &numpoints) || numpoints < 4 || 
  228.                                               numpoints > MAX_CPOINTS)
  229.       goto abort;
  230.     RotCurve[joint].numpoints = numpoints;
  231.     for (point = 0; point < numpoints; point++) {
  232.       if (!fscanf(infile, " %f", &value))
  233.     goto abort;
  234.       RotCurve[joint].xcoords[point] = value;
  235.     }
  236.     for (point = 0; point < numpoints; point++) {
  237.       if (!fscanf(infile, " %f", &value))
  238.     goto abort;
  239.       RotCurve[joint].angles[point] = value;
  240.     }
  241.   }
  242.  
  243.   fclose(infile);
  244.   return 0;
  245.  
  246.   abort:
  247.     fclose(infile);
  248.     fprintf(stderr, "Something went wrong while reading file %s\n", filename);
  249.     FlatCSet();
  250.     return -1;
  251. }
  252.  
  253. void WriteCSetToFile(char *filename)
  254. {
  255.   FILE *outfile = fopen(filename, "w+");
  256.   int joint, point;
  257.  
  258.   if (outfile == NULL) {
  259.     fprintf(stderr, "Error: could not create file %s\n", filename);
  260.     return;
  261.   }
  262.  
  263.   fprintf(outfile, "%d\n", NUM_JOINTS);
  264.  
  265.   fprintf(outfile, "%d\n", MirrorLegs);
  266.  
  267.   for (joint = 0; joint < NUM_JOINTS; joint++) {
  268.  
  269.     fprintf(outfile, "%d\n", RotCurve[joint].numpoints);
  270.  
  271.     for (point = 0; point < RotCurve[joint].numpoints; point++) {
  272.       fprintf(outfile, "%f ", RotCurve[joint].xcoords[point]);
  273.     }
  274.     fprintf(outfile, "\n");
  275.  
  276.     for (point = 0; point < RotCurve[joint].numpoints; point++) {
  277.       fprintf(outfile, "%f ", RotCurve[joint].angles[point]);
  278.     }
  279.     fprintf(outfile, "\n");
  280.   }
  281.  
  282.   fclose(outfile);
  283. }
  284.  
  285. void HandleLoadMenu(int cset)
  286. {
  287.   char filename[MAX_CSETNAMELEN + CSET_EXTLEN + 1];
  288.  
  289.   if (cset == -1) {
  290.     MakeLoadAndSaveMenus();
  291.     CurveMenuInit();
  292.   } else {
  293.     (void)strcpy(filename, CSetNames[cset]);
  294.     (void)strcat(filename, CSET_EXT);
  295.     if (ReadCSetFromFile(filename) == 0) {
  296.       glutSetMenu(SaveMenu);
  297.       glutChangeToMenuEntry(1, CSetNames[cset], cset);
  298.       ComputeCSetAndMakeLists();
  299.       SetWindowTitles(CSetNames[cset]);
  300.       RedisplayBoth();
  301.     }
  302.   }
  303. }
  304.  
  305. void HandleSaveMenu(int cset)
  306. {
  307.   char filename[MAX_CSETNAMELEN + CSET_EXTLEN + 1];
  308.  
  309.   (void)strcpy(filename, CSetNames[cset]);
  310.   (void)strcat(filename, CSET_EXT);
  311.   WriteCSetToFile(filename);
  312.   ComputeCSetAndMakeLists();
  313.   RedisplayBoth();
  314. }
  315.  
  316. int MakeLoadAndSaveMenus(void)
  317. {
  318.   DIR *dirp = opendir(".");
  319.   struct dirent *direntp;
  320.   int csetnum = 0;
  321.   char *newcsetname;
  322.  
  323.   if (LoadMenu != -1)
  324.     glutDestroyMenu(LoadMenu);
  325.   if (SaveMenu != -1)
  326.     glutDestroyMenu(SaveMenu);
  327.  
  328.   SaveMenu = glutCreateMenu(HandleSaveMenu);
  329.   LoadMenu = glutCreateMenu(HandleLoadMenu);
  330.  
  331.   if (dirp == NULL) {
  332.     fprintf(stderr, "Error opening current dir in MakeLoadAndSaveMenus\n");
  333.     return(0);
  334.   }
  335.  
  336.   while ((direntp = readdir(dirp)) != NULL) {
  337.     char *ext = direntp->d_name + (strlen(direntp->d_name) - CSET_EXTLEN);
  338.     if (!strcmp(ext, CSET_EXT)) {
  339.       newcsetname = malloc(strlen(direntp->d_name) - CSET_EXTLEN + 1);
  340.       strncpy(newcsetname, direntp->d_name,
  341.           strlen(direntp->d_name) - CSET_EXTLEN);
  342.       newcsetname[strlen(direntp->d_name) - CSET_EXTLEN] = 0;
  343.       CSetNames[csetnum] = newcsetname;
  344.       glutAddMenuEntry(newcsetname, csetnum++);
  345.     }
  346.   }
  347.   closedir(dirp);
  348.   glutSetMenu(LoadMenu);
  349.   glutAddMenuEntry("-> Rescan Directory <-", -1);
  350.   glutSetMenu(SaveMenu);
  351.   CSetNames[csetnum] = "NewCurve0";
  352.   glutAddMenuEntry("NewCurve0", csetnum++);
  353.   CSetNames[csetnum] = "NewCurve1";
  354.   glutAddMenuEntry("NewCurve1", csetnum++);
  355.   CSetNames[csetnum] = "NewCurve2";
  356.   glutAddMenuEntry("NewCurve2", csetnum++);
  357.  
  358.   return (csetnum - 2);  /* just indicate curves in Load menu */
  359. }
  360.  
  361.  
  362. /***************************************************************/
  363. /********************* DISPLAY LISTS ***************************/
  364. /***************************************************************/
  365.  
  366.  
  367. void MakeCurveList(int joint)
  368. {
  369.   int i;
  370.  
  371.   glNewList(CurveLists+joint, GL_COMPILE);
  372.   glColor3f(1, 1, 1);
  373.   for (i = 0; i < CYCLE_SIZE; i++) {
  374.     glVertex3f((GLfloat)i/CYCLE_SIZE, Walk_cycle[0][joint][i]/180, 0);
  375.   }
  376.   glEndList();
  377. }
  378.  
  379. void MakeCPointList(int joint)
  380. {
  381.   int point;
  382.  
  383.   glNewList(ControlPtsLists+joint, GL_COMPILE);
  384.  
  385.     glColor3f(0, 0.4, 0);
  386.     glBegin(GL_LINE_STRIP);
  387.     for (point = 0; point < RotCurve[joint].numpoints; point++) {
  388.       if (!((point-2) % 3)) {
  389.         glEnd();
  390.         glBegin(GL_LINE_STRIP);
  391.       }
  392.       glVertex3f(RotCurve[joint].xcoords[point],
  393.              (RotCurve[joint].angles[point])/180.0, 0.0);
  394.     }
  395.     glEnd();
  396.  
  397.     glBegin(GL_POINTS);
  398.     for (point = 0; point < RotCurve[joint].numpoints; point++) {
  399.       if (point % 3)
  400.         glColor3f(0, 0.7, 0);
  401.       else
  402.         glColor3f(0.7, 0.0, 0);
  403.       glVertex3f(RotCurve[joint].xcoords[point],
  404.              (RotCurve[joint].angles[point])/180, 0);
  405.     }
  406.     glEnd();
  407.  
  408.   glEndList();
  409. }
  410.  
  411. void MakeJointLists(int joint)
  412. {
  413.   MakeCurveList(joint);
  414.   MakeCPointList(joint);
  415. }
  416.  
  417.  
  418. void ComputeCSetAndMakeLists(void)
  419. {
  420.   int joint;
  421.  
  422.   for(joint = 0; joint < NUM_JOINTS; joint++) {
  423.     ComputeCurve(joint);
  424.     MakeJointLists(joint);
  425.   }
  426. }
  427.  
  428. void MakeLists(void)
  429. {
  430.   HorizontalList = glGenLists(1);
  431.   glNewList(HorizontalList, GL_COMPILE);
  432.   {
  433.     float line1 = 25.0/180,
  434.           line2 = 35.0/180,
  435.           line3 = 45.0/180;
  436.     glColor3f(0, 0, 0.7);
  437.     glPushAttrib(GL_ENABLE_BIT);
  438.     glEnable(GL_LINE_STIPPLE);
  439.     glBegin(GL_LINES);
  440.       glVertex3f(0, 0, 0.5);
  441.       glVertex3f(1, 0, 0.5);
  442.       glVertex3f(0, line1, 0.5);  glVertex3f(1, line1, 0.5);
  443.       glVertex3f(0, -line1, 0.5); glVertex3f(1, -line1, 0.5);
  444.       glVertex3f(0, line2, 0.5);  glVertex3f(1, line2, 0.5);
  445.       glVertex3f(0, -line2, 0.5); glVertex3f(1, -line2, 0.5);
  446.       glVertex3f(0, line3, 0.5);  glVertex3f(1, line3, 0.5);
  447.       glVertex3f(0, -line3, 0.5); glVertex3f(1, -line3, 0.5);
  448.     glEnd();
  449.     glPopAttrib();
  450.   }
  451.   glEndList();
  452.  
  453.  
  454.   CurveLists = glGenLists(NUM_JOINTS);
  455.   assert(CurveLists != 0);
  456.  
  457.   ControlPtsLists = glGenLists(NUM_JOINTS);
  458.   assert(ControlPtsLists != 0);
  459.  
  460.   ComputeCSetAndMakeLists();
  461. }
  462.  
  463. /***************************************************************/
  464. /********************* curve WINDOW ****************************/
  465. /***************************************************************/
  466.  
  467. void CurveReshape(int w, int h)
  468. {
  469.   glViewport(0,0,w,h);
  470.   CurveWWidth = w; 
  471.   CurveWHeight = h;
  472.   glFlush();
  473. }
  474.  
  475. void CurveDisplay(void)
  476. {
  477.   int joint, otherlegstep;
  478.  
  479.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  480.  
  481.   glPushMatrix();
  482.   glTranslatef(0, 0.5, 0);
  483.  
  484.   for (joint = NUM_JOINTS-1; joint >= 0; joint--) {
  485.  
  486.     if (DrawHorizontals) 
  487.       glCallList(HorizontalList);
  488.  
  489.     (CurveAsPoints) ?
  490.     glBegin(GL_POINTS) :
  491.     glBegin(GL_LINE_STRIP);
  492.       glCallList(CurveLists+joint);
  493.     glEnd();
  494.  
  495.     if (joint == EditingCurve) { 
  496.       glPointSize(5.0);
  497.       glCallList(ControlPtsLists+EditingCurve);
  498.       glPointSize(1.0);
  499.     }
  500.   glTranslatef(0, 1, 0);
  501.   }
  502.  
  503.   glPopMatrix();
  504.  
  505.   otherlegstep = (Step+50) % CYCLE_SIZE;
  506.     /* draw vertical line */
  507.   glColor3f(1, 1, 1);
  508.   glBegin(GL_LINES);
  509.     glVertex3f((GLfloat)Step/CYCLE_SIZE, 0, 0);
  510.     glVertex3f((GLfloat)Step/CYCLE_SIZE, NUM_JOINTS, 0);
  511.     if (!MirrorLegs) {
  512.       glVertex3f((GLfloat)otherlegstep/CYCLE_SIZE, 0, 0);
  513.       glVertex3f((GLfloat)otherlegstep/CYCLE_SIZE, NUM_JOINTS, 0);
  514.     }
  515.   glEnd();
  516.  
  517.   glFlush();
  518.   glutSwapBuffers();
  519. }
  520.  
  521.  
  522. void CurveGLInit(void)
  523. {
  524.   glMatrixMode(GL_PROJECTION);
  525.   glLoadIdentity();
  526.   glOrtho(0,1,0,NUM_JOINTS,1,-1);
  527.  
  528.   glMatrixMode(GL_MODELVIEW);
  529.   glLoadIdentity();
  530.  
  531.   glLineStipple(1, 0x00FF);
  532.  
  533.   glEnable(GL_DEPTH_TEST);
  534.   glDepthFunc(GL_LEQUAL);
  535.  
  536.  
  537.   glFlush();
  538.  
  539. } 
  540.  
  541.  
  542.  
  543. void CurveHandleButton(int button, int state, int x, int y)
  544. {
  545.   if (button == GLUT_RIGHT_BUTTON )
  546.     return;
  547.  
  548.   if (state == GLUT_DOWN && CurveDownBtn == -1) {
  549.     if (button == GLUT_MIDDLE_BUTTON)
  550.       CurveHandleMenu(CMENU_WALK);
  551.     else
  552.       fStep = Step = (int)((float)x/glutGet(GLUT_WINDOW_WIDTH) * CYCLE_SIZE);
  553.       
  554.     CurveDownBtn = button;
  555.  
  556.     WasWalking = Walking;
  557.     StopWalking();
  558.     RedisplayBoth();
  559.   } else if (button == CurveDownBtn) {
  560.     CurveDownBtn = -1;
  561.     if (WasWalking) {
  562.       Walking = 1;
  563.       agvSetAllowIdle(0);
  564.       glutIdleFunc(IncrementStep);    
  565.     }
  566.   }
  567. }
  568.  
  569. float CurveEditConstrain(float fx)
  570. {
  571.   if (CurvePickedPoint == 0)
  572.     fx = 0;
  573.   else if (CurvePickedPoint == RotCurve[EditingCurve].numpoints-1)
  574.     fx = 1;
  575.   else if (!(CurvePickedPoint % 3)) {  /* is a pivot */
  576.     fx = MAX(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint-1]);
  577.     fx = MIN(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint+1]);   
  578.     fx = MAX(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint-3]);
  579.     fx = MIN(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint+3]);       
  580.   } else if (!((CurvePickedPoint - 1) % 3)) {   /* is right slope */
  581.     fx = MAX(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint-1]);
  582.   } else {
  583.     fx = MIN(fx, RotCurve[EditingCurve].xcoords[CurvePickedPoint+1]);
  584.   } 
  585.   return fx;
  586. }
  587.  
  588. void RemovePoint(int pt)
  589. {
  590.   int i;
  591.  
  592.   for (i = pt - 1; i < RotCurve[EditingCurve].numpoints; i++) {
  593.     RotCurve[EditingCurve].xcoords[i] = RotCurve[EditingCurve].xcoords[i+3];
  594.     RotCurve[EditingCurve].angles[i]  = RotCurve[EditingCurve].angles[i+3];
  595.   }
  596.   RotCurve[EditingCurve].numpoints -= 3;
  597. }
  598.  
  599. void AddPoint(float fx)
  600. {
  601.   int i, j;
  602.  
  603.   if (fx < 0.05 || fx > 0.95 || RotCurve[EditingCurve].numpoints + 3 >=
  604.                                 MAX_CPOINTS)
  605.     return;
  606.  
  607.   for (i = 3; i < RotCurve[EditingCurve].numpoints; i += 3) {
  608.     if (fx < RotCurve[EditingCurve].xcoords[i]) {
  609.       for (j = RotCurve[EditingCurve].numpoints + 2; j > i + 1; j--) { 
  610.         RotCurve[EditingCurve].xcoords[j] =
  611.                 RotCurve[EditingCurve].xcoords[j-3];
  612.         RotCurve[EditingCurve].angles[j] =
  613.                 RotCurve[EditingCurve].angles[j-3];
  614.       }
  615.     RotCurve[EditingCurve].xcoords[i]   = fx;
  616.     RotCurve[EditingCurve].angles[i]    =
  617.       Walk_cycle[0][EditingCurve][(int)(fx*CYCLE_SIZE)];
  618.     RotCurve[EditingCurve].xcoords[i-1] = fx - 0.05;
  619.     RotCurve[EditingCurve].angles[i-1]  =
  620.       Walk_cycle[0][EditingCurve][(int)((fx-0.05)*CYCLE_SIZE)];
  621.     RotCurve[EditingCurve].xcoords[i+1] = fx + 0.05;
  622.     RotCurve[EditingCurve].angles[i+1]  = 
  623.       Walk_cycle[0][EditingCurve][(int)((fx+0.05)*CYCLE_SIZE)];
  624.     RotCurve[EditingCurve].numpoints += 3;
  625.     break;
  626.     }
  627.   }  
  628. }
  629.  
  630.  
  631. void CurveEditHandleButton(int button, int state, int x, int y)
  632. {
  633.   float fx, fy;
  634.   int point;
  635.  
  636.   fy = -(((float)y - ((float)CurveWHeight/NUM_JOINTS * EditingCurve)) /
  637.        ((float)CurveWHeight/NUM_JOINTS) - 0.5) * 180.0,
  638.   fx = (float)x/CurveWWidth;
  639.   
  640.   if (state == GLUT_DOWN && button == GLUT_LEFT_BUTTON &&
  641.                             CurveDownBtn == -1) {
  642.     CurvePickedPoint = -1;
  643.     
  644.     for (point = 0; point < RotCurve[EditingCurve].numpoints; point++) {
  645.       if (fabs(RotCurve[EditingCurve].xcoords[point] - fx) < 0.01 &&
  646.       fabs(RotCurve[EditingCurve].angles[point] - fy) < 4) {
  647.     CurvePickedPoint = point;
  648.     CurveLastX = x;
  649.     CurveLastY = y;
  650.     glutIdleFunc(CurveCPointDrag);
  651.     break;
  652.       }
  653.     }
  654.    if (CurvePickedPoint == -1)
  655.      CurveHandleButton(button, state, x, y);
  656.     CurveDownBtn = button;
  657.  
  658.  
  659.   } else if (state == GLUT_DOWN && button == GLUT_MIDDLE_BUTTON &&
  660.                                    CurveDownBtn == -1) {
  661.  
  662.     for (point = 3; point < RotCurve[EditingCurve].numpoints - 1; point += 3) {
  663.       if (fabs(RotCurve[EditingCurve].xcoords[point] - fx) < 0.01 &&
  664.       fabs(RotCurve[EditingCurve].angles[point] - fy) < 4) {
  665.     break;
  666.       }
  667.     }
  668.     if (point >= 3 && point < RotCurve[EditingCurve].numpoints - 1)
  669.       RemovePoint(point);
  670.     else if (fabs(Walk_cycle[0][EditingCurve][(int)(fx*CYCLE_SIZE)] - fy) < 4)
  671.       AddPoint(fx);
  672.     ComputeCurve(EditingCurve);
  673.     MakeJointLists(EditingCurve);    
  674.     RedisplayBoth();
  675.  
  676.   } else if (button == GLUT_LEFT_BUTTON && button == CurveDownBtn) {
  677.  
  678.     y = MAX(y, 0); y = MIN(y, CurveWHeight);
  679.     x = MAX(x, 0); x = MIN(x, CurveWWidth);
  680.     fy = -(((float)y - ((float)CurveWHeight/NUM_JOINTS * EditingCurve)) /
  681.          ((float)CurveWHeight/NUM_JOINTS) - 0.5) * 180.0,
  682.     fx = (float)x/CurveWWidth;
  683.     CurveDownBtn = -1;
  684.     if (CurvePickedPoint != -1) {
  685.       fx = CurveEditConstrain(fx);
  686.       RotCurve[EditingCurve].xcoords[CurvePickedPoint] = fx;
  687.       RotCurve[EditingCurve].angles[CurvePickedPoint] = fy;        
  688.       ComputeCurve(EditingCurve);
  689.       MakeJointLists(EditingCurve);
  690.       glutIdleFunc(NULL);
  691.       RedisplayBoth();
  692.     }
  693.   }
  694. }  
  695.  
  696.  
  697. void CurveHandleMotion(int x, int y)
  698. {
  699.   if (CurvePickedPoint == -1) { 
  700.     
  701.     if (CurveDownBtn == GLUT_LEFT_BUTTON || CurveDownBtn ==
  702.                                             GLUT_MIDDLE_BUTTON) {
  703.       Step = (int)((float)x/glutGet(GLUT_WINDOW_WIDTH) * CYCLE_SIZE)
  704.     % CYCLE_SIZE;
  705.       if (Step < 0)
  706.     Step = CYCLE_SIZE + Step;
  707.       fStep = Step;
  708.  
  709.     RedisplayBoth();
  710.     }
  711.   } else {
  712.     y = MAX(y, 0); y = MIN(y, CurveWHeight);
  713.     x = MAX(x, 0); x = MIN(x, CurveWWidth);
  714.     CurveLastX = x;
  715.     CurveLastY = y;
  716.   }
  717. }
  718.  
  719. void CurveCPointDrag(void)
  720. {
  721.   float fx, fy;
  722.  
  723.   if (CurveDownBtn == GLUT_LEFT_BUTTON && CurvePickedPoint != -1) {
  724.     fy = -(((float)CurveLastY -
  725.            ((float)CurveWHeight/NUM_JOINTS * EditingCurve)) /
  726.           ((float)CurveWHeight/NUM_JOINTS) - 0.5) * 180.0,
  727.     fx = (float)CurveLastX/CurveWWidth;
  728.  
  729.     fx = CurveEditConstrain(fx);
  730.     RotCurve[EditingCurve].xcoords[CurvePickedPoint] = fx;
  731.     RotCurve[EditingCurve].angles[CurvePickedPoint] = fy;        
  732.     ComputeCurve(EditingCurve);
  733.     MakeJointLists(EditingCurve);
  734.     RedisplayBoth();
  735.   }
  736. }
  737.  
  738. void CurveHandleKeys(unsigned char key, int x, int y)
  739. {
  740.   if (key > '0' && key < '9')
  741.     CurveHandleEditMenu((key-'0')-1);
  742.   else if (key == 'd')
  743.     CurveHandleMenu(CMENU_DONEEDIT);
  744.   else {
  745.     switch(key) {
  746.       case 'f':
  747.       case ' ': Step++;
  748.                 StopWalking(); break;
  749.       case 'F': Step += 5;
  750.                 StopWalking(); break;
  751.       case 'b': Step--;
  752.                 StopWalking(); break;
  753.       case 'B': Step -= 5; 
  754.                 StopWalking(); break;
  755.     }
  756.     Step %= CYCLE_SIZE;
  757.     if (Step < 0)
  758.       Step = CYCLE_SIZE + Step;
  759.     fStep = Step;
  760.     RedisplayBoth();
  761.   }
  762. }
  763.  
  764. void CurveHandleEditMenu(int curve)
  765. {
  766.   if (curve >= NUM_JOINTS)
  767.     return;
  768.   if (EditingCurve == -1) {
  769.     WasWalking = Walking;
  770.     Walking = 0;
  771.     agvSetAllowIdle(0);   /* don't allow spinning, just slows us down */
  772.     glutIdleFunc(NULL);
  773.     glutMouseFunc(CurveEditHandleButton);
  774.   }
  775.   EditingCurve = curve;
  776.   glutPostRedisplay();
  777. }
  778.  
  779. void CurveHandleSZMenu(int size)
  780. {
  781.   IncStep = (float)size/100;
  782. }
  783.  
  784. void CurveHandleMenu(int value)
  785. {
  786.   switch (value) {
  787.     case CMENU_QUIT:
  788.       exit(0);
  789.       break;
  790.     case CMENU_CURVE:
  791.       CurveAsPoints = !CurveAsPoints;
  792.       glutPostRedisplay();
  793.       break;
  794.     case CMENU_HORIZ:
  795.       DrawHorizontals = !DrawHorizontals;
  796.       glutPostRedisplay();
  797.       break;
  798.     case CMENU_WALK:
  799.       if (EditingCurve != -1)
  800.     break;
  801.       Walking = !Walking;
  802.       if (Walking) {
  803.         agvSetAllowIdle(0);
  804.     glutIdleFunc(IncrementStep);    
  805.       } else {
  806.         agvSetAllowIdle(1);
  807.       }
  808.       break;
  809.     case CMENU_DONEEDIT:
  810.       glutMouseFunc(CurveHandleButton);
  811.       EditingCurve = -1;
  812.       CurvePickedPoint = -1;
  813.       Walking = WasWalking;
  814.       if (Walking)
  815.     glutIdleFunc(IncrementStep);
  816.       else
  817.         agvSetAllowIdle(1);
  818.       glutPostRedisplay();
  819.       break;
  820.     case CMENU_RESET:
  821.       FlatCSet();
  822.       ComputeCSetAndMakeLists();
  823.       glutPostRedisplay();
  824.       break;
  825.     case CMENU_MIRROR:
  826.       MirrorLegs = !MirrorLegs;
  827.       ComputeCSetAndMakeLists();
  828.       glutPostRedisplay();      
  829.     }
  830. }
  831.  
  832. void CurveMenuInit(void)
  833. {
  834.   int i;
  835.   char label[3];
  836.  
  837.   if (CurveEditMenu != -1) {
  838.     glutDestroyMenu(CurveEditMenu);
  839.     glutDestroyMenu(CurveMenu);
  840.     glutDestroyMenu(StepSizeMenu);
  841.   }
  842.  
  843.   CurveEditMenu = glutCreateMenu(CurveHandleEditMenu);
  844.   for (i = 0; i < NUM_JOINTS; i++) {
  845.     sprintf(label, " %d ", i+1);
  846.     glutAddMenuEntry(label, i);
  847.   }
  848.   StepSizeMenu = glutCreateMenu(CurveHandleSZMenu);
  849.   glutAddMenuEntry("0.25", 25);
  850.   glutAddMenuEntry("0.5",  50);
  851.   glutAddMenuEntry("1.0", 100);
  852.   glutAddMenuEntry("2.0", 200);
  853.   glutAddMenuEntry("3.0", 300);
  854.   glutAddMenuEntry("5.0", 500);
  855.   CurveMenu = glutCreateMenu(CurveHandleMenu);
  856.   glutAddSubMenu("Load Curve Set", LoadMenu);
  857.   glutAddSubMenu("Save As Curve Set", SaveMenu);
  858.   glutAddSubMenu("Edit Curve", CurveEditMenu);
  859.   glutAddMenuEntry("Done Editing", CMENU_DONEEDIT);
  860.   glutAddMenuEntry("Flatten Curve Set", CMENU_RESET);
  861.   glutAddMenuEntry("Toggle mirrored", CMENU_MIRROR);
  862.   glutAddSubMenu("Step size", StepSizeMenu);
  863.   glutAddMenuEntry("Toggle dotted", CMENU_CURVE);
  864.   glutAddMenuEntry("Toggle horizontals", CMENU_HORIZ);
  865.   glutAddMenuEntry("Toggle walking", CMENU_WALK);
  866.   glutAddMenuEntry("Quit", CMENU_QUIT);
  867.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  868. }
  869.  
  870. void CurveVisible(int v)
  871. {
  872.   if (v == GLUT_VISIBLE)
  873.     CurveWindowVisible = 1;
  874.   else 
  875.     CurveWindowVisible = 0;
  876. }
  877.  
  878. /***************************************************************/
  879. /*********************** GUY WINDOW ****************************/
  880. /***************************************************************/
  881.  
  882. void GuyDisplay(void)
  883. {
  884.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  885.   glFlush();
  886.  
  887.   glLoadIdentity();
  888.  
  889.   agvViewTransform();
  890.  
  891.   if (DrawAxes)
  892.     glCallList(AxesList);
  893.  
  894.   switch(GuyModel) {
  895.     case WIRECUBE:   DrawTheGuy_WC();  break;
  896.     case SOLIDCUBE:  DrawTheGuy_SC();  break;
  897.     case CYLINDER1:  DrawTheGuy_SL();  break;
  898.     case CYLINDER2:  DrawTheGuy_SL2(); break;
  899.   }
  900.  
  901.   glutSwapBuffers();
  902.   glFlush();
  903. }
  904.  
  905. void GuyReshape(int w, int h)
  906. {
  907.   glViewport(0,0,w,h);
  908.   glMatrixMode(GL_PROJECTION);
  909.   glLoadIdentity();
  910.   if (ViewPerspective)
  911.     gluPerspective(60.0, (GLdouble)w/h, 0.01, 100);
  912.   else
  913.     glOrtho(-1.2, 1.2, -1.2, 1.2, 0.1, 100);
  914.   glMatrixMode(GL_MODELVIEW);
  915.   glFlush();
  916. }
  917.  
  918.  
  919. void GuyGLInit(void)
  920. {
  921.   GLfloat mat_ambient[] = { 1.0, 1.0, 1.0, 1.0 };
  922.   GLfloat light_position[] = { 0.3, 0.5, 0.8, 0.0 };
  923.   GLfloat lm_ambient[] = { 0.2, 0.2, 0.2, 1.0 };
  924.   
  925.   glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
  926.   glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  927.   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lm_ambient);
  928.   
  929.   glEnable(GL_LIGHTING);
  930.   glEnable(GL_LIGHT0);
  931.   glDepthFunc(GL_LESS);
  932.   glEnable(GL_DEPTH_TEST);
  933.   glEnable(GL_NORMALIZE);
  934.   glShadeModel(GL_SMOOTH);
  935.   /* Cylinder stuff */
  936.   StoreTheGuy_SL();
  937.   StoreTheGuy_SL2();
  938. }
  939.  
  940. void GuyHandleKeys(unsigned char key, int x, int y)
  941. {
  942.   switch(key) {
  943.     case 'f':
  944.     case ' ': Step++;
  945.               StopWalking(); break;
  946.     case 'F': Step += 5;
  947.               StopWalking(); break;
  948.     case 'b': Step--;
  949.               StopWalking(); break;
  950.     case 'B': Step -= 5; 
  951.               StopWalking(); break;
  952.   }
  953.   Step %= CYCLE_SIZE;
  954.   if (Step < 0)
  955.     Step = CYCLE_SIZE + Step;
  956.   agvHandleKeys(key, x, y);
  957.   RedisplayBoth();
  958. }
  959.  
  960. typedef enum { GMENU_QUIT, GMENU_CURVE, GMENU_HORIZ,
  961.                GMENU_AXES, GMENU_PERSP } GuyMenuChoices;
  962.  
  963.  
  964. void GuyModelHandleMenu(int model)
  965. {
  966.   GuyModel = model;
  967.   if (model == WIRECUBE)
  968.     glDisable(GL_LIGHTING);
  969.   else
  970.     glEnable(GL_LIGHTING);
  971.   glutPostRedisplay();
  972. }
  973.  
  974. void GuyHandleMenu(int value)
  975. {
  976.   switch (value) {
  977.     case GMENU_QUIT:
  978.       exit(0);
  979.       break;
  980.     case GMENU_AXES:
  981.       DrawAxes = !DrawAxes;
  982.       glutPostRedisplay();
  983.       break;
  984.     case GMENU_PERSP:
  985.       ViewPerspective = !ViewPerspective;
  986.       GuyReshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
  987.       glutPostRedisplay();
  988.       break;
  989.   }
  990. }
  991.  
  992. void GuyMenuInit(void)
  993. {
  994.   int sub2, sub1 = glutCreateMenu(agvSwitchMoveMode);
  995.   glutAddMenuEntry("Flying move",  FLYING);
  996.   glutAddMenuEntry("Polar move",   POLAR);
  997.   sub2 = glutCreateMenu(GuyModelHandleMenu);
  998.   glutAddMenuEntry("Wire cubes",  WIRECUBE);
  999.   glutAddMenuEntry("Solid cubes", SOLIDCUBE);
  1000.   glutAddMenuEntry("Cylinder 1",  CYLINDER1);
  1001.   glutAddMenuEntry("Cylinder 2",  CYLINDER2);
  1002.   glutCreateMenu(GuyHandleMenu);
  1003.   glutAddSubMenu("Viewing", sub1);
  1004.   glutAddSubMenu("Model", sub2);
  1005.   glutAddMenuEntry("Toggle Axes",    GMENU_AXES);
  1006.   glutAddMenuEntry("Toggle Perspective View", GMENU_PERSP);
  1007.   glutAddMenuEntry("Quit",           GMENU_QUIT);
  1008.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  1009. }
  1010.  
  1011. /***************************************************************/
  1012. /********************* BOTH WINDOWS ****************************/
  1013. /***************************************************************/
  1014.  
  1015. void RedisplayBoth(void)
  1016. {
  1017.   glutSetWindow(GuyWindow);
  1018.   glutPostRedisplay();
  1019.   if (CurveWindowVisible) {
  1020.     glutSetWindow(CurveWindow);
  1021.     glutPostRedisplay();
  1022.   }
  1023. }
  1024.  
  1025. void IncrementStep(void)
  1026. {
  1027.   fStep = fmod(fStep + IncStep, CYCLE_SIZE);
  1028.   Step = (int)fStep;
  1029.   if (agvMoving)
  1030.     agvMove();
  1031.   RedisplayBoth();
  1032. }
  1033.  
  1034. void StopWalking(void)
  1035. {
  1036.   if (Walking) {
  1037.     Walking = 0;
  1038.     agvSetAllowIdle(1);
  1039.   }
  1040. }
  1041.  
  1042. void SetWindowTitles(char *csetname)
  1043. {
  1044.   char windowtitle[MAX_CSETNAMELEN + 20];
  1045.  
  1046.   strcpy(windowtitle, "Rotation Curves: ");
  1047.   strcat(windowtitle, csetname);
  1048.   glutSetWindow(CurveWindow);
  1049.   glutSetWindowTitle(windowtitle);
  1050.  
  1051.   strcpy(windowtitle, "The Guy: ");
  1052.   strcat(windowtitle, csetname);
  1053.   glutSetWindow(GuyWindow);
  1054.   glutSetWindowTitle(windowtitle);
  1055. }
  1056.  
  1057. /***************************************************************/
  1058. /***************************** MAIN ****************************/
  1059. /***************************************************************/
  1060.  
  1061. int main(int argc, char** argv)
  1062. {
  1063.   glutInit(&argc, argv);
  1064.  
  1065.   glutInitWindowSize(512, 512);
  1066.   glutInitWindowPosition(700, 250);
  1067.   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  1068.   GuyWindow = glutCreateWindow("The Guy:");
  1069.   agvInit(!Walking);
  1070.   AxesList = glGenLists(1);
  1071.   agvMakeAxesList(AxesList);
  1072.   GuyGLInit();
  1073.   GuyMenuInit();
  1074.   glutDisplayFunc(GuyDisplay);
  1075.   glutReshapeFunc(GuyReshape);
  1076.   glutKeyboardFunc(GuyHandleKeys);
  1077.  
  1078.   glutInitWindowSize(512, 1024);
  1079.   glutInitWindowPosition(100, 0);
  1080.   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  1081.   CurveWindow = glutCreateWindow("Rotation Curves:");
  1082.   CurveGLInit();
  1083.   glutDisplayFunc(CurveDisplay);
  1084.   glutReshapeFunc(CurveReshape);
  1085.   glutMouseFunc(CurveHandleButton);
  1086.   glutMotionFunc(CurveHandleMotion);
  1087.   glutKeyboardFunc(CurveHandleKeys);
  1088.   glutVisibilityFunc(CurveVisible);
  1089.  
  1090.   FlatCSet();
  1091.   MakeLists();
  1092.  
  1093.   if (MakeLoadAndSaveMenus() > 0)  /* read first curve if there was one */
  1094.     HandleLoadMenu(0);
  1095.  
  1096.   CurveMenuInit();
  1097.  
  1098.   glutMainLoop();
  1099.   return 0;             /* ANSI C requires main to return int. */
  1100. }
  1101.  
  1102.  
  1103.  
  1104.  
  1105.